import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;

public class LeetCode {

  /**
   * 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。
   * <p>
   * 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
   * <p>
   * 链接：https://leetcode-cn.com/problems/two-sum
   *
   * @param nums
   * @param target
   * @return
   */
  public static int[] twoSum(int[] nums, int target) {
    nums = Arrays.stream(nums).filter(value -> value <= target).toArray();
    int length = nums.length;
    for (int i = 0; i < length - 1; i++) {
      for (int j = i + 1; j < length; j++) {
        if (nums[i] + nums[j] == target) {
          return new int[]{i, j};
        }
      }
    }
    return null;
  }

  /**
   * 求反
   *
   * @param value
   * @return
   */
  public static int reversal(int value) {
    int result = 0;
    while (value > 0) {
      result = result * 10 + value % 10;
      value = value / 10;
    }
    return result;
  }

  /**
   * 给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
   * <p>
   * 请你将两个数相加，并以相同形式返回一个表示和的链表。
   * <p>
   * 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
   * <p>
   * 链接：https://leetcode-cn.com/problems/add-two-numbers
   */
  public static class ListSumNumbers {

    public static class ListNode {

      int val;
      ListNode next;

      ListNode() {
      }

      ListNode(int val) {
        this.val = val;
      }

      ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
      }

    }

    private static void buildNext(ListNode listNode, int val) {
      if (val >= 10) {
        listNode.next = new ListNode(1);
        val = val - 10;
      }
      listNode.val = val;
    }

    private static ListNode addTwoNumbers(ListNode listNode, ListNode l1, ListNode l2) {
      int val = getValue(l1) + getValue(l2) + getValue(listNode);
      buildNext(listNode, val);
      if (!Objects.isNull(l1) || !Objects.isNull(l2)) {
        addTwoNumbers(getNext(listNode), getNext(l1), getNext(l2));
      }

      return listNode;
    }

    private static ListNode getNext(ListNode listNode) {
      return Objects.isNull(listNode) ? null : listNode.next;
    }

    private static int getValue(ListNode listNode) {
      return Objects.isNull(listNode) ? 0 : listNode.val;
    }

    private static Integer[] addTwoNumbers(int[] il1, int[] il2) {
      ListNode l1 = buildListNode(il1, 0);
      ListNode l2 = buildListNode(il2, 0);
      ListNode listNode = addTwoNumbers(new ListNode(), l1, l2);
      List<Integer> list = new ArrayList();
      getInts(listNode, list);
      return list.toArray(new Integer[list.size()]);
    }

    private static void getInts(ListNode listNode, List list) {
      list.add(listNode.val);
      if (!Objects.isNull(listNode.next)) {
        getInts(listNode.next, list);
      }
    }

    private static ListNode buildListNode(int[] values, int deep) {
      if (deep < values.length - 1) {
        return new ListNode(values[deep], buildListNode(values, ++deep));
      }
      return new ListNode(values[deep]);
    }

  }

  public static void main(String[] args) {
    System.out.println(Arrays.toString(twoSum(new int[]{2, 7, 11, 15}, 9)));
    System.out.println(reversal(1234567));
    System.out.println(Arrays.toString(
        ListSumNumbers.addTwoNumbers(new int[]{9, 9, 9, 9, 9, 9, 9}, new int[]{9, 9, 9, 9})));
  }
}
